#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "sha256.h"
#include "logic_functions.h"
#include "to_bigend.h"


#define ROR(x, y)       (((x) >> ((y) & 31)) | ((x) << (32 - ((y) & 31))))
#define Ch(x, y, z)     (z ^ (x & (y ^ z)))
#define Maj(x, y, z)    (((x | y) & z) | (x & y))
#define S(x, n)         ROR((x), (n))
#define R(x, n)         ((x) >> (n))
#define Sigma0(x)       (S(x, 2) ^ S(x, 13) ^ S(x, 22))
#define Sigma1(x)       (S(x, 6) ^ S(x, 11) ^ S(x, 25))
#define Gamma0(x)       (S(x, 7) ^ S(x, 18) ^ R(x, 3))
#define Gamma1(x)       (S(x, 17) ^ S(x, 19) ^ R(x, 10))


const size_t chunk_size = 512 / 8 * sizeof(uint8_t);
const size_t hash_size = 8 * sizeof(uint32_t);
const unsigned int updata_time_in_piece = piece_size / 64;


/* 为 buffer 的 16 个 4 字节元素转换字节序 */
static void reverse_byte_order_for_buffer(uint32_t *buffer)
{
    uint32_t value;
    uint8_t times = 16;

    while (times--) 
    {
        value = *buffer;
        value = ( ( value & 0xFF00FF00L ) >> 8  ) | \
                ( ( value & 0x00FF00FFL ) << 8 );
        *buffer++ = ( value << 16 ) | ( value >> 16 );
    }
}


sha256_context* new_context()
{
    sha256_context* context = malloc(sizeof(sha256_context));
    context->buffer = malloc(chunk_size);
    context->buffer_size = 0;
    context->length = 0;

    context->hash_array[0] = 0x6a09e667;
    context->hash_array[1] = 0xbb67ae85;
    context->hash_array[2] = 0x3c6ef372;
    context->hash_array[3] = 0xa54ff53a;
    context->hash_array[4] = 0x510e527f;
    context->hash_array[5] = 0x9b05688c;
    context->hash_array[6] = 0x1f83d9ab;
    context->hash_array[7] = 0x5be0cd19;

    return context;
}


void destroy_context(sha256_context* context)
{
    free(context->buffer);
    free(context);
}


static void update_chunk(sha256_context* context)
{
    /*
     * The size of chunk
     * must be 64 Bytes
     */

    int i;
    uint32_t S[8], W[64], t0, t1;

    memcpy(W, context->buffer, chunk_size);
    reverse_byte_order_for_buffer(W);

    for (i = 16; i < 64; ++i) 
        W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16];

    S[0] = context->hash_array[0];
    S[1] = context->hash_array[1];
    S[2] = context->hash_array[2];
    S[3] = context->hash_array[3];
    S[4] = context->hash_array[4];
    S[5] = context->hash_array[5];
    S[6] = context->hash_array[6];
    S[7] = context->hash_array[7];
    
    /* Compress */
#define RND(a, b, c, d, e, f, g, h, i, ki)          \
    t0 = h + Sigma1(e) + Ch(e, f, g) + ki + W[i];   \
    t1 = Sigma0(a) + Maj(a, b, c);                  \
    d += t0;                                        \
    h  = t0 + t1;

    RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],0,0x428a2f98);
    RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],1,0x71374491);
    RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],2,0xb5c0fbcf);
    RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],3,0xe9b5dba5);
    RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],4,0x3956c25b);
    RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],5,0x59f111f1);
    RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],6,0x923f82a4);
    RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],7,0xab1c5ed5);
    RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],8,0xd807aa98);
    RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],9,0x12835b01);
    RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],10,0x243185be);
    RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],11,0x550c7dc3);
    RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],12,0x72be5d74);
    RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],13,0x80deb1fe);
    RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],14,0x9bdc06a7);
    RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],15,0xc19bf174);
    RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],16,0xe49b69c1);
    RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],17,0xefbe4786);
    RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],18,0x0fc19dc6);
    RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],19,0x240ca1cc);
    RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],20,0x2de92c6f);
    RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],21,0x4a7484aa);
    RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],22,0x5cb0a9dc);
    RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],23,0x76f988da);
    RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],24,0x983e5152);
    RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],25,0xa831c66d);
    RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],26,0xb00327c8);
    RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],27,0xbf597fc7);
    RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],28,0xc6e00bf3);
    RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],29,0xd5a79147);
    RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],30,0x06ca6351);
    RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],31,0x14292967);
    RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],32,0x27b70a85);
    RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],33,0x2e1b2138);
    RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],34,0x4d2c6dfc);
    RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],35,0x53380d13);
    RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],36,0x650a7354);
    RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],37,0x766a0abb);
    RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],38,0x81c2c92e);
    RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],39,0x92722c85);
    RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],40,0xa2bfe8a1);
    RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],41,0xa81a664b);
    RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],42,0xc24b8b70);
    RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],43,0xc76c51a3);
    RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],44,0xd192e819);
    RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],45,0xd6990624);
    RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],46,0xf40e3585);
    RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],47,0x106aa070);
    RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],48,0x19a4c116);
    RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],49,0x1e376c08);
    RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],50,0x2748774c);
    RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],51,0x34b0bcb5);
    RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],52,0x391c0cb3);
    RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],53,0x4ed8aa4a);
    RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],54,0x5b9cca4f);
    RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],55,0x682e6ff3);
    RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],56,0x748f82ee);
    RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],57,0x78a5636f);
    RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],58,0x84c87814);
    RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],59,0x8cc70208);
    RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],60,0x90befffa);
    RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],61,0xa4506ceb);
    RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],62,0xbef9a3f7);
    RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],63,0xc67178f2);

#undef RND

    /* feedback */
    for(i = 0; i < 8; i++)
        context->hash_array[i] += S[i];
    
    context->buffer_size = 0;
}


void update(sha256_context* context, uint8_t* data, size_t data_size)
{
    context->length += data_size * 8;
    size_t want_size = chunk_size - context->buffer_size;
    
    if(context->buffer_size)
    {
        want_size = chunk_size - context->buffer_size;
        want_size = want_size > data_size ? data_size : want_size;
        
        memcpy
        (
            context->buffer + context->buffer_size,
            data,
            want_size
        );
        
        data_size -= want_size;
        data += want_size;

        context->buffer_size += want_size;
        if(context->buffer_size == chunk_size)
            update_chunk(context);
        else
            return;
    }

    while(data_size >= chunk_size)
    {
        memcpy
        (
            context->buffer,
            data,
            chunk_size
        );

        update_chunk(context);

        data += chunk_size;
        data_size -= chunk_size;
    }

    memcpy
    (
        context->buffer,
        data,
        data_size
    );
    context->buffer_size = data_size;
}


// void update(sha256_context* context, uint8_t* data, size_t data_size)
// {
//     context->length += data_size * 8;
//     size_t want_size = chunk_size - context->buffer_size;

//     while(data_size > want_size)
//     {
//         memcpy
//         (
//             context->buffer + context->buffer_size,
//             data,
//             want_size
//         );

//         update_chunk(context);

//         data += want_size;
//         data_size -= want_size;
//         want_size = chunk_size - context->buffer_size;
//     }

//     memcpy
//     (
//         context->buffer + context->buffer_size,
//         data,
//         data_size
//     );
//     context->buffer_size += data_size;
// }


void update_piece(sha256_context* context, uint8_t* data)
{
    context->length += piece_size * 8;
    uint8_t* buffer_save = context->buffer;
    unsigned int n = updata_time_in_piece / 16;
    
    while(n--)
    {
        context->buffer = data; update_chunk(context); data += chunk_size;
        context->buffer = data; update_chunk(context); data += chunk_size;
        context->buffer = data; update_chunk(context); data += chunk_size;
        context->buffer = data; update_chunk(context); data += chunk_size;
        context->buffer = data; update_chunk(context); data += chunk_size;
        context->buffer = data; update_chunk(context); data += chunk_size;
        context->buffer = data; update_chunk(context); data += chunk_size;
        context->buffer = data; update_chunk(context); data += chunk_size;
        context->buffer = data; update_chunk(context); data += chunk_size;
        context->buffer = data; update_chunk(context); data += chunk_size;
        context->buffer = data; update_chunk(context); data += chunk_size;
        context->buffer = data; update_chunk(context); data += chunk_size;
        context->buffer = data; update_chunk(context); data += chunk_size;
        context->buffer = data; update_chunk(context); data += chunk_size;
        context->buffer = data; update_chunk(context); data += chunk_size;
        context->buffer = data; update_chunk(context); data += chunk_size;
    }

    context->buffer = buffer_save;
}


void update_n_chunk(sha256_context* context, uint8_t* data, size_t data_size)
{
    context->length += data_size * 8;
    unsigned int n = data_size / chunk_size;
    uint8_t* buffer_save = context->buffer;
    
    while(n--)
    {
        context->buffer = data;
        update_chunk(context);
        data += chunk_size;
    }

    context->buffer = buffer_save;
}


static inline void affix_length(sha256_context* context)
{    
    uint64_t temp;

    temp = context->length;
    temp =  ((temp & 0xff00ff00ff00ff00llu) >> 8) | 
            ((temp & 0x00ff00ff00ff00ffllu) << 8);
    
    temp =  ((temp & 0xffff0000ffff0000llu) >> 16) | 
            ((temp & 0x0000ffff0000ffffllu) << 16);
    temp = (temp << 32) | (temp >> 32);
    
    *((uint64_t*)(context->buffer + chunk_size - 8))
    = temp;
}


void digest(sha256_context* context)
{
    memset
    (
        context->buffer + context->buffer_size,
        0,
        chunk_size - context->buffer_size
    );

    if(context->buffer_size <= chunk_size - 1 - 8)  // enough space to affix tail and length
    {
        context->buffer[context->buffer_size] = 0x80;

        affix_length(context);
        update_chunk(context);
    }
    else if(context->buffer_size <= chunk_size - 1) // enough space to affix tail only
    {
        context->buffer[context->buffer_size] = 0x80;
        update_chunk(context);

        // 后面再 digest 不对，因为它会进入到上一面的分支，导致又补了个 0x80
        // digest(context);
        
        memset(context->buffer, 0, chunk_size);
        affix_length(context);
        update_chunk(context);
    }
    else                                            // buffer hold 512 bits data already
    {
        update_chunk(context);
        digest(context);
    }
}


void get_digest(sha256_context* context, uint8_t* digest_array)
{
    int i;
    for(i = 0; i < 32; i++)
        digest_array[i] = context->hash_array[i >> 2] >> (8 * (3 - (i & 3)));
}


//uint main()
//{
//    build_mask();
//    length = 0x12ff;
//    char* length_address;
//    length_address = &length;
//
//    printf("%x, %x", *(length_address + 0), *(length_address + 1));
//    return 0;
//}
